/**
 * Copyright (c) 2011 eelpo.com
 * All rights reserved.
 */
package com.eelpo.common.query;

import java.util.Collection;

import com.eelpo.common.query.criteria.Criteria;
import com.eelpo.common.query.expression.BetweenExpression;
import com.eelpo.common.query.expression.EmptyOrNullExpression;
import com.eelpo.common.query.expression.ExistsExpression;
import com.eelpo.common.query.expression.InExpression;
import com.eelpo.common.query.expression.JpqlExpression;
import com.eelpo.common.query.expression.LogicalExpression;
import com.eelpo.common.query.expression.MemberOfExpression;
import com.eelpo.common.query.expression.ParameterCriterion;
import com.eelpo.common.query.expression.SimpleExpression;
import com.eelpo.common.query.expression.SimplePropertyExpression;
import com.eelpo.common.util.BlankUtils;

/**
 * <pre>
 * 
 * 表达式构建工厂代理
 * 
 * </pre>
 * 
 * @author <a href="mailto:Brian@eelpo.com">汪洪州</a>
 * @since 1.0
 */
public class Expression {

	/**
	 * 逻辑表达式
	 * 
	 * @param lhs
	 *            表达式
	 * @param rhs
	 *            表达式
	 * @return 返回复合逻辑表达式
	 */
	public static LogicalExpression and(ParameterCriterion lhs, ParameterCriterion rhs) {
		return LogicalExpression.getAndExpression(lhs, rhs);
	}

	/**
	 * 逻辑表达式
	 * 
	 * @param lhs
	 *            表达式
	 * @param rhs
	 *            表达式
	 * @return 返回复合逻辑表达式
	 */
	public static LogicalExpression or(ParameterCriterion lhs, ParameterCriterion rhs) {
		return LogicalExpression.getOrExpression(lhs, rhs);
	}

	/**
	 * between表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param lo
	 *            开始值
	 * @param hi
	 *            结束值
	 * @return 返回between表达式
	 */
	public static BetweenExpression between(String propertyName, Object lo, Object hi) {
		return BetweenExpression.getBetweenExpression(propertyName, lo, hi);
	}

	/**
	 * between表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param lo
	 *            开始值
	 * @param hi
	 *            结束值
	 * @return 返回between表达式
	 */
	public static BetweenExpression betweenInornate(String propertyName, Object lo, Object hi) {
		return BetweenExpression.getBetweenInornateExpression(propertyName, lo, hi);
	}

	/**
	 * between表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param lo
	 *            开始值
	 * @param hi
	 *            结束值
	 * @return 返回between表达式
	 */
	public static BetweenExpression notBetween(String propertyName, Object lo, Object hi) {
		return BetweenExpression.getNotBetweenExpression(propertyName, lo, hi);
	}

	/**
	 * between表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param lo
	 *            开始值
	 * @param hi
	 *            结束值
	 * @return 返回between表达式
	 */
	public static BetweenExpression notBetweenInornate(String propertyName, Object lo, Object hi) {
		return BetweenExpression.getNotBetweenInornateExpression(propertyName, lo, hi);
	}

	/**
	 * 不等于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回等于表达式
	 */
	public static SimpleExpression ne(String propertyName, Object value) {
		return SimpleExpression.getNeExpression(propertyName, value);
	}

	/**
	 * 不等于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回等于表达式
	 */
	public static SimpleExpression neInornate(String propertyName, Object value) {
		return SimpleExpression.getNeInornateExpression(propertyName, value);
	}

	/**
	 * 属性不等于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param otherPropertyName
	 *            其他属性名
	 * @return 返回属性不等于表达式
	 */
	public static SimplePropertyExpression neProperty(String propertyName, String otherPropertyName) {
		return SimplePropertyExpression.getNeExpression(propertyName, otherPropertyName);
	}

	/**
	 * 等于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回等于表达式
	 */
	public static SimpleExpression eq(String propertyName, Object value) {
		return SimpleExpression.getEqExpression(propertyName, value);
	}

	/**
	 * 等于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回等于表达式
	 */
	public static SimpleExpression eqInornate(String propertyName, Object value) {
		return SimpleExpression.getEqInornateExpression(propertyName, value);
	}

	/**
	 * 属性等于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param otherPropertyName
	 *            其他属性名
	 * @return 返回属性等于表达式
	 */
	public static SimplePropertyExpression eqProperty(String propertyName, String otherPropertyName) {
		return SimplePropertyExpression.getEqExpression(propertyName, otherPropertyName);
	}

	/**
	 * 大于等于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回大于等于表达式
	 */
	public static SimpleExpression ge(String propertyName, Object value) {
		return SimpleExpression.getGeExpression(propertyName, value);
	}

	/**
	 * 大于等于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回大于等于表达式
	 */
	public static SimpleExpression geInornate(String propertyName, Object value) {
		return SimpleExpression.getGeInornateExpression(propertyName, value);
	}

	/**
	 * 属性大于等于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param otherPropertyName
	 *            其他属性名
	 * @return 返回属性大于等于表达式
	 */
	public static SimplePropertyExpression geProperty(String propertyName, String otherPropertyName) {
		return SimplePropertyExpression.getGeExpression(propertyName, otherPropertyName);
	}

	/**
	 * 大于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回大于表达式
	 */
	public static SimpleExpression gt(String propertyName, Object value) {
		return SimpleExpression.getGtExpression(propertyName, value);
	}

	/**
	 * 大于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回大于表达式
	 */
	public static SimpleExpression gtInornate(String propertyName, Object value) {
		return SimpleExpression.getGtInornateExpression(propertyName, value);
	}

	/**
	 * 属性大于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param otherPropertyName
	 *            其他属性名
	 * @return 返回属性大于表达式
	 */
	public static SimplePropertyExpression gtProperty(String propertyName, String otherPropertyName) {
		return SimplePropertyExpression.getGtExpression(propertyName, otherPropertyName);
	}

	/**
	 * 小于等于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回小于等于表达式
	 */
	public static SimpleExpression le(String propertyName, Object value) {
		return SimpleExpression.getLeExpression(propertyName, value);
	}

	/**
	 * 小于等于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回小于等于表达式
	 */
	public static SimpleExpression leInornate(String propertyName, Object value) {
		return SimpleExpression.getLeInornateExpression(propertyName, value);
	}

	/**
	 * 属性小于等于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param otherPropertyName
	 *            其他属性名
	 * @return 返回属性小于等于表达式
	 */
	public static SimplePropertyExpression leProperty(String propertyName, String otherPropertyName) {
		return SimplePropertyExpression.getLeExpression(propertyName, otherPropertyName);
	}

	/**
	 * 小于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回小于表达式
	 */
	public static SimpleExpression lt(String propertyName, Object value) {
		return SimpleExpression.getLtExpression(propertyName, value);
	}

	/**
	 * 小于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回小于表达式
	 */
	public static SimpleExpression ltInornate(String propertyName, Object value) {
		return SimpleExpression.getLtInornateExpression(propertyName, value);
	}

	/**
	 * 属性小于表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param otherPropertyName
	 *            其他属性名
	 * @return 返回属性小于表达式
	 */
	public static SimplePropertyExpression ltProperty(String propertyName, String otherPropertyName) {
		return SimplePropertyExpression.getLtExpression(propertyName, otherPropertyName);
	}

	/**
	 * like表达试,默认匹配模式为anywhere
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回like 表达试
	 */
	public static SimpleExpression like(String propertyName, Object value) {
		return like(propertyName, value, MatchMode.ANYWHERE);
	}

	/**
	 * like表达试
	 * 
	 * @param propertyName属性名
	 * @param value
	 *            属性参数值
	 * @param matchMode
	 *            匹配模式
	 * @return 返回like 表达试
	 */
	public static SimpleExpression like(String propertyName, Object value, MatchMode matchMode) {
		return SimpleExpression.getLikeExpression(propertyName, matchMode.getParameter(value));
	}

	/**
	 * like表达试,默认匹配模式为anywhere
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回like 表达试
	 */
	public static SimpleExpression likeInornate(String propertyName, Object value) {
		return likeInornate(propertyName, value, MatchMode.ANYWHERE);
	}

	/**
	 * like表达试
	 * 
	 * @param propertyName属性名
	 * @param value
	 *            属性参数值
	 * @param matchMode
	 *            匹配模式
	 * @return 返回like 表达试
	 */
	public static SimpleExpression likeInornate(String propertyName, Object value, MatchMode matchMode) {
		return SimpleExpression.getLikeInornateExpression(propertyName, matchMode.getParameter(value));
	}

	/**
	 * not like表达试,默认匹配模式为anywhere
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回not like表达试
	 */
	public static SimpleExpression notLike(String propertyName, Object value) {
		return notLike(propertyName, value, MatchMode.ANYWHERE);
	}

	/**
	 * not like表达试
	 * 
	 * @param propertyName属性名
	 * @param value
	 *            属性参数值
	 * @param matchMode
	 *            匹配模式
	 * @return 返回not like 表达试
	 */
	public static SimpleExpression notLike(String propertyName, Object value, MatchMode matchMode) {
		return SimpleExpression.getNotLikeExpression(propertyName, matchMode.getParameter(value));
	}

	/**
	 * not like表达试,默认匹配模式为anywhere
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回not like表达试
	 */
	public static SimpleExpression notLikeInornate(String propertyName, Object value) {
		return notLikeInornate(propertyName, value, MatchMode.ANYWHERE);
	}

	/**
	 * not like表达试
	 * 
	 * @param propertyName属性名
	 * @param value
	 *            属性参数值
	 * @param matchMode
	 *            匹配模式
	 * @return 返回not like 表达试
	 */
	public static SimpleExpression notLikeInornate(String propertyName, Object value, MatchMode matchMode) {
		return SimpleExpression.getNotLikeInornateExpression(propertyName, matchMode.getParameter(value));
	}

	/**
	 * ilike表达试,默认匹配模式为anywhere
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回ilike 表达试
	 */
	public static SimpleExpression ilike(String propertyName, Object value) {
		return ilike(propertyName, value, MatchMode.ANYWHERE);
	}

	/**
	 * ilike表达试
	 * 
	 * @param propertyName属性名
	 * @param value
	 *            属性参数值
	 * @param matchMode
	 *            匹配模式
	 * @return 返回ilike 表达试
	 */
	public static SimpleExpression ilike(String propertyName, Object value, MatchMode matchMode) {
		return SimpleExpression.getILikeExpression(propertyName, matchMode.getParameter(value));
	}

	/**
	 * ilike表达试,默认匹配模式为anywhere
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回ilike 表达试
	 */
	public static SimpleExpression ilikeInornate(String propertyName, Object value) {
		return ilikeInornate(propertyName, value, MatchMode.ANYWHERE);
	}

	/**
	 * ilike表达试
	 * 
	 * @param propertyName属性名
	 * @param value
	 *            属性参数值
	 * @param matchMode
	 *            匹配模式
	 * @return 返回ilike 表达试
	 */
	public static SimpleExpression ilikeInornate(String propertyName, Object value, MatchMode matchMode) {
		return SimpleExpression.getILikeInornateExpression(propertyName, matchMode.getParameter(value));
	}

	/**
	 * not ilike表达试,默认匹配模式为anywhere
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回not ilike 表达试
	 */
	public static SimpleExpression notIlike(String propertyName, Object value) {
		return notIlike(propertyName, value, MatchMode.ANYWHERE);
	}

	/**
	 * not ilike表达试
	 * 
	 * @param propertyName属性名
	 * @param value
	 *            属性参数值
	 * @param matchMode
	 *            匹配模式
	 * @return 返回not ilike 表达试
	 */
	public static SimpleExpression notIlike(String propertyName, Object value, MatchMode matchMode) {
		return SimpleExpression.getNotILikeExpression(propertyName, matchMode.getParameter(value));
	}

	/**
	 * not ilike表达试,默认匹配模式为anywhere
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性参数值
	 * @return 返回not ilike 表达试
	 */
	public static SimpleExpression notIlikeInornate(String propertyName, Object value) {
		return notIlikeInornate(propertyName, value, MatchMode.ANYWHERE);
	}

	/**
	 * not ilike表达试
	 * 
	 * @param propertyName属性名
	 * @param value
	 *            属性参数值
	 * @param matchMode
	 *            匹配模式
	 * @return 返回not ilike 表达试
	 */
	public static SimpleExpression notIlikeInornate(String propertyName, Object value, MatchMode matchMode) {
		return SimpleExpression.getNotILikeInornateExpression(propertyName, matchMode.getParameter(value));
	}

	/**
	 * Member Of表达试
	 * 
	 * @param listProperty
	 *            集合属性
	 * @param value
	 *            成员值
	 * @return 返回Member Of表达试
	 */
	public static MemberOfExpression memberOf(String listProperty, Object value) {
		return MemberOfExpression.getMemberOfExpression(listProperty, value);
	}

	/**
	 * not Member Of表达试,默认匹配模式为anywhere
	 * 
	 * @param listProperty
	 *            集合属性
	 * @param value
	 *            成员值
	 * @return 返回not Member Of表达试
	 */
	public static MemberOfExpression notMemberOf(String listProperty, Object value) {
		return MemberOfExpression.getNotMemberOfExpression(listProperty, value);
	}

	/**
	 * Member Of表达试
	 * 
	 * @param listProperty
	 *            集合属性
	 * @param value
	 *            成员值
	 * @return 返回Member Of表达试
	 */
	public static MemberOfExpression memberOfInornate(String listProperty, Object value) {
		return MemberOfExpression.getMemberOfInornateExpression(listProperty, value);
	}

	/**
	 * not Member Of表达试,默认匹配模式为anywhere
	 * 
	 * @param listProperty
	 *            集合属性
	 * @param value
	 *            成员值
	 * @return 返回not Member Of表达试
	 */
	public static MemberOfExpression notMemberOfInornate(String listProperty, Object value) {
		return MemberOfExpression.getNotMemberOfInornateExpression(listProperty, value);
	}

	/**
	 * is empty表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @return 返回is empty表达式
	 */
	public static EmptyOrNullExpression isEmpty(String propertyName) {
		return EmptyOrNullExpression.getEmptyExpression(propertyName);
	}

	/**
	 * is not empty表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @return 返回is not empty表达式
	 */
	public static EmptyOrNullExpression isNotEmpty(String propertyName) {
		return EmptyOrNullExpression.getNotEmptyExpression(propertyName);
	}

	/**
	 * is null表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @return 返回is null表达式
	 */
	public static EmptyOrNullExpression isNull(String propertyName) {
		return EmptyOrNullExpression.getNullExpression(propertyName);
	}

	/**
	 * is not null表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @return 返回is not null表达式
	 */
	public static EmptyOrNullExpression isNotNull(String propertyName) {
		return EmptyOrNullExpression.getNotNullExpression(propertyName);
	}

	/**
	 * is empty表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @return 返回is empty表达式
	 */
	public static EmptyOrNullExpression isEmptyInornate(String propertyName) {
		return EmptyOrNullExpression.getEmptyInornateExpression(propertyName);
	}

	/**
	 * is not empty表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @return 返回is not empty表达式
	 */
	public static EmptyOrNullExpression isNotEmptyInornate(String propertyName) {
		return EmptyOrNullExpression.getNotEmptyInornateExpression(propertyName);
	}

	/**
	 * is null表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @return 返回is null表达式
	 */
	public static EmptyOrNullExpression isNullInornate(String propertyName) {
		return EmptyOrNullExpression.getNullInornateExpression(propertyName);
	}

	/**
	 * is not null表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @return 返回is not null表达式
	 */
	public static EmptyOrNullExpression isNotNullInornate(String propertyName) {
		return EmptyOrNullExpression.getNotNullInornateExpression(propertyName);
	}

	/**
	 * in 表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param values
	 *            参数集合
	 * @return 返回in 表达式
	 */
	public static ParameterCriterion in(String propertyName, Collection<?> values) {
		if (BlankUtils.isBlank(values)) {
			return null;
		}

		if (values.size() > 2) {
			return InExpression.getInExpression(propertyName, values);
		} else if (values.size() == 2) {
			return LogicalExpression.getOrExpression(SimpleExpression.getEqExpression(propertyName, values.iterator().next()),
					SimpleExpression.getEqExpression(propertyName, values.iterator().next()));
		} else {
			return SimpleExpression.getEqExpression(propertyName, values.iterator().next());
		}
	}

	/**
	 * in 表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param values
	 *            参数集合
	 * @return 返回in 表达式
	 */
	public static ParameterCriterion in(String propertyName, Object[] values) {

		if (BlankUtils.isBlank(values)) {
			return null;
		}

		if (values.length > 2) {
			return InExpression.getInExpression(propertyName, values);
		} else if (values.length == 2) {
			return LogicalExpression.getOrExpression(SimpleExpression.getEqExpression(propertyName, values[0]), SimpleExpression.getEqExpression(propertyName, values[1]));
		} else {
			return SimpleExpression.getEqExpression(propertyName, values[0]);
		}
	}

	/**
	 * in 表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param criteria
	 *            子查询
	 * @return 返回in 表达式
	 */
	public static InExpression in(String propertyName, Criteria criteria) {
		return InExpression.getInExpression(propertyName, criteria);
	}

	/**
	 * not in 表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param values
	 *            参数集合
	 * @return 返回not in 表达式
	 */
	public static ParameterCriterion notIn(String propertyName, Collection<?> values) {

		if (BlankUtils.isBlank(values)) {
			return null;
		}

		if (values.size() > 2) {
			return InExpression.getNotInExpression(propertyName, values);
		} else if (values.size() == 2) {
			return LogicalExpression.getAndExpression(SimpleExpression.getNeExpression(propertyName, values.iterator().next()),
					SimpleExpression.getNeExpression(propertyName, values.iterator().next()));
		} else {
			return SimpleExpression.getNeExpression(propertyName, values.iterator().next());
		}
	}

	/**
	 * not in 表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param values
	 *            参数集合
	 * @return 返回not in 表达式
	 */
	public static ParameterCriterion notIn(String propertyName, Object[] values) {

		if (BlankUtils.isBlank(values)) {
			return null;
		}

		if (values.length > 2) {
			return InExpression.getNotInExpression(propertyName, values);
		} else if (values.length == 2) {
			return LogicalExpression.getAndExpression(SimpleExpression.getNeExpression(propertyName, values[0]), SimpleExpression.getNeExpression(propertyName, values[1]));
		} else {
			return SimpleExpression.getNeExpression(propertyName, values[0]);
		}
	}

	/**
	 * not in 表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param criteria
	 *            子查询
	 * @return 返回not in 表达式
	 */
	public static InExpression notIn(String propertyName, Criteria criteria) {
		return InExpression.getNotInExpression(propertyName, criteria);
	}

	/**
	 * in 表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param values
	 *            参数集合
	 * @return 返回in 表达式
	 */
	public static ParameterCriterion inInornate(String propertyName, Collection<?> values) {

		if (BlankUtils.isBlank(values)) {
			return null;
		}

		if (values.size() > 2) {
			return InExpression.getInInornateExpression(propertyName, values);
		} else if (values.size() == 2) {
			return LogicalExpression.getOrExpression(SimpleExpression.getEqInornateExpression(propertyName, values.iterator().next()),
					SimpleExpression.getEqInornateExpression(propertyName, values.iterator().next()));
		} else {
			return SimpleExpression.getEqInornateExpression(propertyName, values.iterator().next());
		}
	}

	/**
	 * in 表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param values
	 *            参数集合
	 * @return 返回in 表达式
	 */
	public static ParameterCriterion inInornate(String propertyName, Object[] values) {

		if (BlankUtils.isBlank(values)) {
			return null;
		}

		if (values.length > 2) {
			return InExpression.getInInornateExpression(propertyName, values);
		} else if (values.length == 2) {
			return LogicalExpression.getOrExpression(SimpleExpression.getEqInornateExpression(propertyName, values[0]),
					SimpleExpression.getEqInornateExpression(propertyName, values[1]));
		} else {
			return SimpleExpression.getEqInornateExpression(propertyName, values[0]);
		}
	}

	/**
	 * in 表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param criteria
	 *            子查询
	 * @return 返回in 表达式
	 */
	public static InExpression inInornate(String propertyName, Criteria criteria) {
		return InExpression.getInInornateExpression(propertyName, criteria);
	}

	/**
	 * not in 表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param values
	 *            参数集合
	 * @return 返回not in 表达式
	 */
	public static ParameterCriterion notInInornate(String propertyName, Collection<?> values) {

		if (BlankUtils.isBlank(values)) {
			return null;
		}

		if (values.size() > 2) {
			return InExpression.getNotInInornateExpression(propertyName, values);
		} else if (values.size() == 2) {
			return LogicalExpression.getAndExpression(SimpleExpression.getNeInornateExpression(propertyName, values.iterator().next()),
					SimpleExpression.getNeInornateExpression(propertyName, values.iterator().next()));
		} else {
			return SimpleExpression.getNeInornateExpression(propertyName, values.iterator().next());
		}
	}

	/**
	 * not in 表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param values
	 *            参数集合
	 * @return 返回not in 表达式
	 */
	public static ParameterCriterion notInInornate(String propertyName, Object[] values) {

		if (BlankUtils.isBlank(values)) {
			return null;
		}

		if (values.length > 2) {
			return InExpression.getNotInInornateExpression(propertyName, values);
		} else if (values.length == 2) {
			return LogicalExpression.getAndExpression(SimpleExpression.getNeInornateExpression(propertyName, values[0]),
					SimpleExpression.getNeInornateExpression(propertyName, values[1]));
		} else {
			return SimpleExpression.getNeInornateExpression(propertyName, values[0]);
		}

	}

	/**
	 * not in 表达式
	 * 
	 * @param propertyName
	 *            属性名
	 * @param criteria
	 *            子查询
	 * @return 返回not in 表达式
	 */
	public static InExpression notInInornate(String propertyName, Criteria criteria) {
		return InExpression.getNotInInornateExpression(propertyName, criteria);
	}

	/**
	 * not exists表达式
	 * 
	 * @param criteria
	 *            子查询
	 * @return 返回exists表达式
	 */
	public static ExistsExpression exists(Criteria criteria) {
		return ExistsExpression.getExistsExpression(criteria);
	}

	/**
	 * not exists表达式
	 * 
	 * @param criteria
	 *            子查询
	 * @return 返回exists表达式
	 */
	public static ExistsExpression notExists(Criteria criteria) {
		return ExistsExpression.getNotExistsExpression(criteria);
	}

	/**
	 * jpql表达式
	 * 
	 * @param jpql
	 *            jpql语句
	 * @return 返回jpql表达式
	 */
	public static JpqlExpression andJpql(String jpql) {
		return JpqlExpression.getAndJpqlExpression(jpql);
	}

	/**
	 * jpql表达式
	 * 
	 * @param jpql
	 *            jpql语句
	 * @param values
	 *            jpql语句对应参数
	 * @return 返回jpql表达式
	 */
	public static JpqlExpression andJpql(String jpql, Object... values) {
		return JpqlExpression.getAndJpqlExpression(jpql, values);
	}

	/**
	 * jpql表达式
	 * 
	 * @param jpql
	 *            jpql语句
	 * @return 返回jpql表达式
	 */
	public static JpqlExpression orJpql(String jpql) {
		return JpqlExpression.getOrJpqlExpression(jpql);
	}

	/**
	 * jpql表达式
	 * 
	 * @param jpql
	 *            jpql语句
	 * @param values
	 *            jpql语句对应参数
	 * @return 返回jpql表达式
	 */
	public static JpqlExpression orJpql(String jpql, Object... values) {
		return JpqlExpression.getOrJpqlExpression(jpql, values);
	}
}